{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [电影评论文本分类](https://www.tensorflow.org/tutorials/keras/text_classification?hl=zh-cn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-01-22 02:55:29.503462: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import re\n",
    "import shutil\n",
    "import string\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.13.0\n"
     ]
    }
   ],
   "source": [
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz\n",
      "84125825/84125825 [==============================] - 10s 0us/step\n"
     ]
    }
   ],
   "source": [
    "url = \"https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz\"\n",
    "\n",
    "dataset = tf.keras.utils.get_file(\"aclImdb_v1\", url,\n",
    "                                    untar=True, cache_dir='.',\n",
    "                                    cache_subdir='')\n",
    "\n",
    "dataset_dir = os.path.join(os.path.dirname(dataset), 'aclImdb')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['test', 'train', 'imdbEr.txt', 'imdb.vocab', 'README']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir(dataset_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['neg',\n",
       " 'pos',\n",
       " 'unsup',\n",
       " 'unsupBow.feat',\n",
       " 'labeledBow.feat',\n",
       " 'urls_neg.txt',\n",
       " 'urls_pos.txt',\n",
       " 'urls_unsup.txt']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dir = os.path.join(dataset_dir, 'train')\n",
    "os.listdir(train_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rachel Griffiths writes and directs this award winning short film. A heartwarming story about coping with grief and cherishing the memory of those we've loved and lost. Although, only 15 minutes long, Griffiths manages to capture so much emotion and truth onto film in the short space of time. Bud Tingwell gives a touching performance as Will, a widower struggling to cope with his wife's death. Will is confronted by the harsh reality of loneliness and helplessness as he proceeds to take care of Ruth's pet cow, Tulip. The film displays the grief and responsibility one feels for those they have loved and lost. Good cinematography, great direction, and superbly acted. It will bring tears to all those who have lost a loved one, and survived.\n"
     ]
    }
   ],
   "source": [
    "sample_file = os.path.join(train_dir, 'pos/1181_9.txt')\n",
    "with open(sample_file) as f:\n",
    "  print(f.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "remove_dir = os.path.join(train_dir, 'unsup')\n",
    "shutil.rmtree(remove_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 25000 files belonging to 2 classes.\n",
      "Using 20000 files for training.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-01-22 02:56:30.039083: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1639] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 10400 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 3060, pci bus id: 0000:09:00.0, compute capability: 8.6\n"
     ]
    }
   ],
   "source": [
    "batch_size = 32\n",
    "seed = 42\n",
    "\n",
    "raw_train_ds = tf.keras.utils.text_dataset_from_directory(\n",
    "    'aclImdb/train', \n",
    "    batch_size=batch_size, \n",
    "    validation_split=0.2, \n",
    "    subset='training', \n",
    "    seed=seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Review b\"Having seen most of Ringo Lam's films, I can say that this is his best film to date, and the most unusual. It's a ancient china period piece cranked full of kick-ass martial arts, where the location of an underground lair full of traps and dungeons plays as big a part as any of the characters. The action is fantastic, the story is tense and entertaining, and the set design is truely memorable. Sadly, Burning Paradise has not been made available on DVD and vhs is next-to-impossible to get your mitts on, even if you near the second biggest china-town in North America (like I do). If you can find it, don't pass it up.\"\n",
      "Label 1\n",
      "Review b'Caution: May contain spoilers...<br /><br />I\\'ve seen this movie 3 times & I\\'ve liked it every time. Upon seeing it again, I\\'m always reminded of how good it is. An HBO TV movie- very well done like most of their movies are- this would\\'ve gotten Oscars for it\\'s performances had it been released for general distribution instead of made for TV.<br /><br />As I\\'m sure anyone knows from reading other reviews here, this is the story of serial murderer, Andrei Chikatilo. He murdered 56 people over 8 years in the former Soviet Union. (3 victims were buried & couldn\\'t be found so he was only convicted of 52 out of 53 of his murders.) The story actually focuses more on the forensic analyst, Victor Burakov played to perfection by Stephen Rea. A man that becomes tortured and obsessed with finding this killer despite the additional obstacles placed by party hacks, his part is essential to be sure. There is a very touching scene towards the end of the movie that mentions how in America, investigators are routinely taken off serial killer cases after 18 months whether they want to or not due to the mental strain & frustration. According to this acct, Burakov worked for over 5 years before getting his first break from it. He followed the case to its conclusion, 3 years later. In this scene, his superior, General Fetisov, played by Donald Sutherland, actually tells him he admires his dedication and apologizes for not knowing he should\\'ve given him a break sooner.<br /><br />Rea\\'s performance is so well done, he doesn\\'t overact, chew up the scenery or do anything that distracts from his portrayal of a man who is hell bent on finding his killer. He is a man with passion, but doesn\\'t show it in the same manner as is so usually portrayed in detective movies. He only occasionally gives outbursts after quietly putting up with more than most could stand under such circumstances. Rea does so much with his face, his eyes, he doesn\\'t need to overact. He just *is* - His character, so frustrated after so long, at one point, driven to frustration, he actually says he\\'d rather find 3 at one time than none in a year. Of course what he means is not that he wants more people to die, he just wants some clues to catch this man. Rea makes us feel for this man. He makes us understand but a glimpse of what it is to live with such horror and futility.<br /><br />A mutant to be sure, Chikatilo\\'s childhood was one which produces such \"monsters.\" The character of Chikatilo is very well done by Jeffrey DeMunn. He somehow (impossible though it may seem) elicits some modicum of sympathy for himself. Perhaps he is the worst of us gone terribly wrong? Either way, his performance is very well done.<br /><br />Donald Sutherland as Colonel Fetisov (later promoted to General) also does a great job. He starts out seeming to be a cynical worldly official that doesn\\'t seem much more interested in helping the investigation than anyone else blocking Burakov. But he eventually becomes more than just an assistant, he actually actively participates in helping Burakov. There is also a very nice turn by Max Von Sydow as the psychiatrist brought in to help profile and figure out what kind of deviant they are looking for.<br /><br />Although this movie deals with a morbid, grotesque and violent story, it really is more about what it takes to catch a killer than the killer himself. All around a very well done movie with fine performances and a great screenplay. The screenplay manages to do what the best of this type of movie does: give factual events & place them meaningfully inside a dramatic framework that makes you feel like you know the people *behind* the facts.<br /><br />9 out of 10 stars'\n",
      "Label 1\n",
      "Review b\"from the view of a NASCAR Maniac like I am, the movie is interesting. You can see many race cars from 1983. Even tough, the racing scenes are not that much realistic. But I have to admit, that I haven't seen any race before 1995, because before that time, they didn't show any NASCAR races in Germany)<br /><br />from the view of a Burt Reynolds fan like I am, the movie basically is what we are used to see from Reynolds in the 80's: Burt behind the wheel of a fast car, like in his Bandit Movies.<br /><br />If you love NASCAR and Burt Reynolds, this movie is a must-see. If you only love one of this 2 things, I also recommend to watch it. If you like neither NASCAR nor Burt Reynolds, you still should give it a chance, but remember, this movie was far away from winning an Oscar Academy Award.<br /><br />It is the typical humor of the 80's. If you like movies like the Cannonball Movies, and Police Academy, you will also like that one.\"\n",
      "Label 1\n"
     ]
    }
   ],
   "source": [
    "for text_batch, label_batch in raw_train_ds.take(1):\n",
    "    for i in range(3):\n",
    "        print(\"Review\", text_batch.numpy()[i])\n",
    "        print(\"Label\", label_batch.numpy()[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label 0 corresponds to neg\n",
      "Label 1 corresponds to pos\n"
     ]
    }
   ],
   "source": [
    "print(\"Label 0 corresponds to\", raw_train_ds.class_names[0])\n",
    "print(\"Label 1 corresponds to\", raw_train_ds.class_names[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 25000 files belonging to 2 classes.\n",
      "Using 5000 files for validation.\n"
     ]
    }
   ],
   "source": [
    "raw_val_ds = tf.keras.utils.text_dataset_from_directory(\n",
    "    'aclImdb/train', \n",
    "    batch_size=batch_size, \n",
    "    validation_split=0.2, \n",
    "    subset='validation', \n",
    "    seed=seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 25000 files belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "raw_test_ds = tf.keras.utils.text_dataset_from_directory(\n",
    "    'aclImdb/test', \n",
    "    batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，您将使用有用的 tf.keras.layers.TextVectorization 层对数据进行标准化、词例化和向量化。\n",
    "\n",
    "标准化是指对文本进行预处理，通常是移除标点符号或 HTML 元素以简化数据集。词例化是指将字符串分割成词例（例如，通过空格将句子分割成单个单词）。向量化是指将词例转换为数字，以便将它们输入神经网络。所有这些任务都可以通过这个层完成。\n",
    "\n",
    "正如您在上面看到的，评论包含各种 HTML 代码，例如 <br />。TextVectorization 层（默认情况下会将文本转换为小写并去除标点符号，但不会去除 HTML）中的默认标准化程序不会移除这些代码。您将编写一个自定义标准化函数来移除 HTML。\n",
    "\n",
    "注：为了防止训练-测试偏差（也称为训练-应用偏差），在训练和测试时间对数据进行相同的预处理非常重要。为此，可以将 TextVectorization 层直接包含在模型中，如本教程后面所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def custom_standardization(input_data):\n",
    "    lowercase = tf.strings.lower(input_data)\n",
    "    stripped_html = tf.strings.regex_replace(lowercase, '<br />', ' ')\n",
    "    return tf.strings.regex_replace(stripped_html,\n",
    "                                    '[%s]' % re.escape(string.punctuation),\n",
    "                                    '')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_features = 10000\n",
    "sequence_length = 250\n",
    "\n",
    "vectorize_layer = layers.TextVectorization(\n",
    "    standardize=custom_standardization,\n",
    "    max_tokens=max_features,\n",
    "    output_mode='int',\n",
    "    output_sequence_length=sequence_length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a text-only dataset (without labels), then call adapt\n",
    "train_text = raw_train_ds.map(lambda x, y: x)\n",
    "vectorize_layer.adapt(train_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vectorize_text(text, label):\n",
    "    text = tf.expand_dims(text, -1)\n",
    "    return vectorize_layer(text), label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Review tf.Tensor(b'Belmondo is a tough cop. He goes after a big-time drug dealer (played by Henry Silva, normally a great villain - see \"Sharky\\'s Machine\"; but here he is clearly dubbed, and because of that he lacks his usual charisma). He goes to the scuzziest places of Paris and Marseilles, asks for some names, beats up some people, gets the names, goes to more scuzzy places, asks for more names, beats up more people, etc. The whole movie is punch after punch after punch. It seems that the people who made it had no other ambition than to create the French equivalent of \"Dirty Harry\". Belmondo, who was 50 here, does perform some good stunts at the beginning; apart from those, \"Le Marginal\" is a violent, episodic, trite, shallow and forgettable cop movie. (*1/2)', shape=(), dtype=string)\n",
      "Label neg\n",
      "Vectorized review (<tf.Tensor: shape=(1, 250), dtype=int64, numpy=\n",
      "array([[   1,    7,    4, 1233, 1021,   27,  261,  101,    4,    1, 1525,\n",
      "        6992,  248,   32, 1488,    1, 1659,    4,   86, 1011,   67,    1,\n",
      "        1707,   18,  128,   27,    7,  688, 2396,    3,   84,    5,   12,\n",
      "          27, 1453,   24,  616, 3314,   27,  261,    6,    2,    1, 1329,\n",
      "           5, 1371,    3,    1, 1581,   15,   46, 1356, 3612,   56,   46,\n",
      "          79,  201,    2, 1356,  261,    6,   50,    1, 1329, 1581,   15,\n",
      "          50, 1356, 3612,   56,   50,   79,  532,    2,  211,   17,    7,\n",
      "        2851,  101, 2851,  101, 2851,    9,  180,   12,    2,   79,   36,\n",
      "          90,    9,   66,   57,   78, 5415,   70,    6,  916,    2,  800,\n",
      "        4891,    5, 1678, 1347,    1,   36,   13, 1732,  128,  120, 3078,\n",
      "          46,   49, 3274,   31,    2,  435,  948,   35,  143, 3519,    1,\n",
      "           7,    4, 1097, 9578, 3092, 2056,    3, 2512, 1021,   17, 1105,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0]])>, <tf.Tensor: shape=(), dtype=int32, numpy=0>)\n"
     ]
    }
   ],
   "source": [
    "# retrieve a batch (of 32 reviews and labels) from the dataset\n",
    "text_batch, label_batch = next(iter(raw_train_ds))\n",
    "first_review, first_label = text_batch[0], label_batch[0]\n",
    "print(\"Review\", first_review)\n",
    "print(\"Label\", raw_train_ds.class_names[first_label])\n",
    "print(\"Vectorized review\", vectorize_text(first_review, first_label))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1287 --->  silent\n",
      " 313 --->  night\n",
      "Vocabulary size: 10000\n"
     ]
    }
   ],
   "source": [
    "print(\"1287 ---> \",vectorize_layer.get_vocabulary()[1287])\n",
    "print(\" 313 ---> \",vectorize_layer.get_vocabulary()[313])\n",
    "print('Vocabulary size: {}'.format(len(vectorize_layer.get_vocabulary())))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ds = raw_train_ds.map(vectorize_text)\n",
    "val_ds = raw_val_ds.map(vectorize_text)\n",
    "test_ds = raw_test_ds.map(vectorize_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "AUTOTUNE = tf.data.AUTOTUNE\n",
    "\n",
    "train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)\n",
    "val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)\n",
    "test_ds = test_ds.cache().prefetch(buffer_size=AUTOTUNE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_dim = 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " embedding (Embedding)       (None, None, 16)          160016    \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, None, 16)          0         \n",
      "                                                                 \n",
      " global_average_pooling1d (  (None, 16)                0         \n",
      " GlobalAveragePooling1D)                                         \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 16)                0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 1)                 17        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 160033 (625.13 KB)\n",
      "Trainable params: 160033 (625.13 KB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = tf.keras.Sequential([\n",
    "    layers.Embedding(max_features + 1, embedding_dim),\n",
    "    layers.Dropout(0.2),\n",
    "    layers.GlobalAveragePooling1D(),\n",
    "    layers.Dropout(0.2),\n",
    "    layers.Dense(1)])\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss=losses.BinaryCrossentropy(from_logits=True),\n",
    "              optimizer='adam',\n",
    "              metrics=tf.metrics.BinaryAccuracy(threshold=0.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-01-22 03:00:59.669417: I tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:606] TensorFloat-32 will be used for the matrix multiplication. This will only be logged once.\n",
      "2025-01-22 03:00:59.681884: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x14b800a7e4e0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2025-01-22 03:00:59.681924: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): NVIDIA GeForce RTX 3060, Compute Capability 8.6\n",
      "2025-01-22 03:00:59.714305: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:255] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
      "2025-01-22 03:00:59.774156: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:432] Loaded cuDNN version 8900\n",
      "2025-01-22 03:01:00.052218: I ./tensorflow/compiler/jit/device_compiler.h:186] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "625/625 [==============================] - 80s 124ms/step - loss: 0.6634 - binary_accuracy: 0.6902 - val_loss: 0.6137 - val_binary_accuracy: 0.7752\n",
      "Epoch 2/10\n",
      "625/625 [==============================] - 3s 5ms/step - loss: 0.5473 - binary_accuracy: 0.8018 - val_loss: 0.4974 - val_binary_accuracy: 0.8212\n",
      "Epoch 3/10\n",
      "625/625 [==============================] - 3s 5ms/step - loss: 0.4441 - binary_accuracy: 0.8458 - val_loss: 0.4198 - val_binary_accuracy: 0.8462\n",
      "Epoch 4/10\n",
      "625/625 [==============================] - 3s 5ms/step - loss: 0.3780 - binary_accuracy: 0.8658 - val_loss: 0.3735 - val_binary_accuracy: 0.8598\n",
      "Epoch 5/10\n",
      "625/625 [==============================] - 3s 5ms/step - loss: 0.3354 - binary_accuracy: 0.8786 - val_loss: 0.3451 - val_binary_accuracy: 0.8670\n",
      "Epoch 6/10\n",
      "625/625 [==============================] - 3s 5ms/step - loss: 0.3042 - binary_accuracy: 0.8887 - val_loss: 0.3261 - val_binary_accuracy: 0.8706\n",
      "Epoch 7/10\n",
      "625/625 [==============================] - 3s 5ms/step - loss: 0.2811 - binary_accuracy: 0.8990 - val_loss: 0.3125 - val_binary_accuracy: 0.8742\n",
      "Epoch 8/10\n",
      "625/625 [==============================] - 3s 5ms/step - loss: 0.2618 - binary_accuracy: 0.9052 - val_loss: 0.3033 - val_binary_accuracy: 0.8748\n",
      "Epoch 9/10\n",
      "625/625 [==============================] - 3s 5ms/step - loss: 0.2449 - binary_accuracy: 0.9131 - val_loss: 0.2970 - val_binary_accuracy: 0.8794\n",
      "Epoch 10/10\n",
      "625/625 [==============================] - 3s 5ms/step - loss: 0.2314 - binary_accuracy: 0.9164 - val_loss: 0.2921 - val_binary_accuracy: 0.8792\n"
     ]
    }
   ],
   "source": [
    "epochs = 10\n",
    "history = model.fit(\n",
    "    train_ds,\n",
    "    validation_data=val_ds,\n",
    "    epochs=epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "782/782 [==============================] - 3s 3ms/step - loss: 0.3098 - binary_accuracy: 0.8743\n",
      "Loss:  0.3097909688949585\n",
      "Accuracy:  0.8742799758911133\n"
     ]
    }
   ],
   "source": [
    "loss, accuracy = model.evaluate(test_ds)\n",
    "\n",
    "print(\"Loss: \", loss)\n",
    "print(\"Accuracy: \", accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['loss', 'binary_accuracy', 'val_loss', 'val_binary_accuracy'])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history_dict = history.history\n",
    "history_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history_dict['binary_accuracy']\n",
    "val_acc = history_dict['val_binary_accuracy']\n",
    "loss = history_dict['loss']\n",
    "val_loss = history_dict['val_loss']\n",
    "\n",
    "epochs = range(1, len(acc) + 1)\n",
    "\n",
    "# \"bo\" is for \"blue dot\"\n",
    "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
    "# b is for \"solid blue line\"\n",
    "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "782/782 [==============================] - 5s 6ms/step - loss: 0.3098 - accuracy: 0.8743\n",
      "0.8742799758911133\n"
     ]
    }
   ],
   "source": [
    "export_model = tf.keras.Sequential([\n",
    "    vectorize_layer,\n",
    "    model,\n",
    "    layers.Activation('sigmoid')\n",
    "])\n",
    "\n",
    "export_model.compile(\n",
    "    loss=losses.BinaryCrossentropy(from_logits=False), optimizer=\"adam\", metrics=['accuracy']\n",
    ")\n",
    "\n",
    "# Test it with `raw_test_ds`, which yields raw strings\n",
    "loss, accuracy = export_model.evaluate(raw_test_ds)\n",
    "print(accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 202ms/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0.65021396],\n",
       "       [0.47713426],\n",
       "       [0.39248624]], dtype=float32)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "examples = [\n",
    "    \"The movie was great!\",\n",
    "    \"The movie was okay.\",\n",
    "    \"The movie was terrible...\"\n",
    "]\n",
    "\n",
    "export_model.predict(examples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
